use std::mem::size_of;
use super::super::core::error::FFIError;
use super::super::core::error::FFIResult;
use super::unsafe_helpers;

// 数值工具结构体
pub struct NumberUtils;

impl NumberUtils {
    // 从字节数组读取u8
    pub fn read_u8(buffer: *const u8, offset: u32) -> FFIResult<u8> {
        // 检查指针是否为空
        if buffer.is_null() {
            return Err(FFIError::NullPointer);
        }
        
        // 使用unsafe_helpers中的安全包装函数
        unsafe {
            Ok(unsafe_helpers::unsafe_read_u8(buffer, offset))
        }
    }
    
    // 将u8写入字节数组
    pub fn write_u8(buffer: *mut u8, offset: u32, value: u8) -> FFIResult<()> {
        // 检查指针是否为空
        if buffer.is_null() {
            return Err(FFIError::NullPointer);
        }
        
        // 使用unsafe_helpers中的安全包装函数
        unsafe {
            unsafe_helpers::unsafe_write_u8(buffer, offset, value);
        }
        
        Ok(())
    }
    
    // 从字节数组读取u16（小端序）
    pub fn read_u16_le(buffer: *const u8, offset: u32) -> FFIResult<u16> {
        // 检查指针是否为空
        if buffer.is_null() {
            return Err(FFIError::NullPointer);
        }
        
        // 使用unsafe_helpers中的安全包装函数
        unsafe {
            Ok(unsafe_helpers::unsafe_read_u16_le(buffer, offset))
        }
    }
    
    // 将u16写入字节数组（小端序）
    pub fn write_u16_le(buffer: *mut u8, offset: u32, value: u16) -> FFIResult<()> {
        // 检查指针是否为空
        if buffer.is_null() {
            return Err(FFIError::NullPointer);
        }
        
        // 使用unsafe_helpers中的安全包装函数
        unsafe {
            unsafe_helpers::unsafe_write_u16_le(buffer, offset, value);
        }
        
        Ok(())
    }
    
    // 从字节数组读取u32（小端序）
    pub fn read_u32_le(buffer: *const u8, offset: u32) -> FFIResult<u32> {
        // 检查指针是否为空
        if buffer.is_null() {
            return Err(FFIError::NullPointer);
        }
        
        // 使用unsafe_helpers中的安全包装函数
        unsafe {
            Ok(unsafe_helpers::unsafe_read_u32_le(buffer, offset))
        }
    }
    
    // 将u32写入字节数组（小端序）
    pub fn write_u32_le(buffer: *mut u8, offset: u32, value: u32) -> FFIResult<()> {
        // 检查指针是否为空
        if buffer.is_null() {
            return Err(FFIError::NullPointer);
        }
        
        // 使用unsafe_helpers中的安全包装函数
        unsafe {
            unsafe_helpers::unsafe_write_u32_le(buffer, offset, value);
        }
        
        Ok(())
    }
    
    // 从字节数组读取u64（小端序）
    pub fn read_u64_le(buffer: *const u8, offset: u32) -> FFIResult<u64> {
        // 检查指针是否为空
        if buffer.is_null() {
            return Err(FFIError::NullPointer);
        }
        
        // 使用unsafe_helpers中的安全包装函数
        unsafe {
            Ok(unsafe_helpers::unsafe_read_u64_le(buffer, offset))
        }
    }
    
    // 将u64写入字节数组（小端序）
    pub fn write_u64_le(buffer: *mut u8, offset: u32, value: u64) -> FFIResult<()> {
        // 检查指针是否为空
        if buffer.is_null() {
            return Err(FFIError::NullPointer);
        }
        
        // 使用unsafe_helpers中的安全包装函数
        unsafe {
            unsafe_helpers::unsafe_write_u64_le(buffer, offset, value);
        }
        
        Ok(())
    }
    
    // 检查缓冲区大小是否足够
    pub fn check_buffer_size(buffer_size: u32, required_size: u32) -> FFIResult<()> {
        if buffer_size < required_size {
            Err(FFIError::BufferTooSmall)
        } else {
            Ok(())
        }
    }
    
    // 计算类型的大小
    pub fn size_of_type<T>() -> u32 {
        size_of::<T>() as u32
    }
}